在 Java 中，`sorted` 操作用于对集合或流中的元素进行排序。`sorted` 通常与 `Stream` API 结合使用，但也可以通过其他方式实现。以下是几种常见的 `sorted` 实现方式：

---

### **1. 使用 `Stream` API（Java 8+）**
`Stream` API 提供了 `sorted` 方法，可以对流中的元素进行排序。

#### **示例：对整数列表进行排序**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);

        // 使用 Stream 对列表进行排序
        List<Integer> sortedNumbers = numbers.stream()
                .sorted() // 默认升序排序
                .collect(Collectors.toList());

        System.out.println(sortedNumbers); // 输出: [1, 2, 3, 4, 5]
    }
}
```

#### **示例：对字符串列表进行排序**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("banana", "apple", "cherry");

        // 使用 Stream 对字符串列表进行排序
        List<String> sortedWords = words.stream()
                .sorted() // 默认字典序排序
                .collect(Collectors.toList());

        System.out.println(sortedWords); // 输出: [apple, banana, cherry]
    }
}
```

---

### **2. 自定义排序规则**
可以通过传递 `Comparator` 来自定义排序规则。

#### **示例：按字符串长度排序**
```java
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("banana", "apple", "cherry");

        // 按字符串长度排序
        List<String> sortedByLength = words.stream()
                .sorted(Comparator.comparingInt(String::length)) // 按长度升序
                .collect(Collectors.toList());

        System.out.println(sortedByLength); // 输出: [apple, cherry, banana]
    }
}
```

#### **示例：按对象字段排序**
```java
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class SortedExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 30),
                new Person("Charlie", 20)
        );

        // 按年龄升序排序
        List<Person> sortedByAge = people.stream()
                .sorted(Comparator.comparingInt(Person::getAge)) // 按年龄排序
                .collect(Collectors.toList());

        System.out.println(sortedByAge); // 输出: [Charlie (20), Alice (25), Bob (30)]
    }
}
```

---

### **3. 使用 `Collections.sort`**
如果不使用 `Stream`，可以通过 `Collections.sort` 对列表进行排序。

#### **示例：对整数列表进行排序**
```java
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class SortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);

        // 使用 Collections.sort 对列表进行排序
        Collections.sort(numbers);

        System.out.println(numbers); // 输出: [1, 2, 3, 4, 5]
    }
}
```

#### **示例：对字符串列表进行自定义排序**
```java
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortedExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("banana", "apple", "cherry");

        // 按字符串长度排序
        Collections.sort(words, Comparator.comparingInt(String::length));

        System.out.println(words); // 输出: [apple, cherry, banana]
    }
}
```

---

### **4. 对数组进行排序**
使用 `Arrays.sort` 对数组进行排序。

#### **示例：对整数数组进行排序**
```java
import java.util.Arrays;

public class SortedExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 1, 4, 2};

        // 使用 Arrays.sort 对数组进行排序
        Arrays.sort(numbers);

        System.out.println(Arrays.toString(numbers)); // 输出: [1, 2, 3, 4, 5]
    }
}
```

#### **示例：对字符串数组进行自定义排序**
```java
import java.util.Arrays;
import java.util.Comparator;

public class SortedExample {
    public static void main(String[] args) {
        String[] words = {"banana", "apple", "cherry"};

        // 按字符串长度排序
        Arrays.sort(words, Comparator.comparingInt(String::length));

        System.out.println(Arrays.toString(words)); // 输出: [apple, cherry, banana]
    }
}
```

---

### **5. 降序排序**
可以通过 `Comparator.reverseOrder()` 或自定义 `Comparator` 实现降序排序。

#### **示例：对整数列表进行降序排序**
```java
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);

        // 使用 Stream 对列表进行降序排序
        List<Integer> sortedDescending = numbers.stream()
                .sorted(Comparator.reverseOrder()) // 降序排序
                .collect(Collectors.toList());

        System.out.println(sortedDescending); // 输出: [5, 4, 3, 2, 1]
    }
}
```

#### **示例：对字符串列表进行降序排序**
```java
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("banana", "apple", "cherry");

        // 按字典序降序排序
        List<String> sortedDescending = words.stream()
                .sorted(Comparator.reverseOrder()) // 降序排序
                .collect(Collectors.toList());

        System.out.println(sortedDescending); // 输出: [cherry, banana, apple]
    }
}
```

---

### **总结**
- **`Stream` API**：推荐使用，简洁高效。
- **`Collections.sort`**：适合直接对列表排序。
- **`Arrays.sort`**：适合对数组排序。
- **自定义排序规则**：通过 `Comparator` 实现。
- **降序排序**：使用 `Comparator.reverseOrder()` 或自定义 `Comparator`。

根据具体需求选择合适的方式！如果有其他问题，请随时提问。